/**
 * 计算rowSpan
 * @param {Array} data [原数据]
 * @param {Array} keys [数据键]--->根据想同key合并
 * @param {Any} sortKey [排序]--->默认不填都升序！升序+逆序[asc,desc] ''/false/undefined不排序
 * @returns {Array,Object} - 返回数据:  [处理后的data,额外的行Arr]
 * 额外的行Arr: 根据每一个排序后的key值, 里面是{'索引':{}}位置，然后'索引':{ rowSpan: x, val: [合并后的数据] }  --->可以不需要使用
 */
// 定义返回值类型
type ComputedRowAndDataResult = [
  any[],
  Record<string, Record<number, { rowSpan: number; val: any[] }>>,
];

export const computedRowAndData = (
  data: any[],
  keys: string[],
  sortKey: any[] = [],
): ComputedRowAndDataResult => {
  // 如果没有传递 sortOrder，默认设置为 ['asc']，表示所有字段按升序排序
  const order =
    sortKey?.length === 0 ? Array(keys.length).fill('asc') : sortKey;
  const sortKeyName = ['asc', 'desc']; // 排序名
  let dataCopy = []; // 排序数组
  const rowSpanArr = {}; // 行对象

  // 所有排序
  dataCopy = [...data].sort((a, b) => {
    for (let i = 0; i < keys.length; i++) {
      const key = keys[i];
      if (order?.length > 0 && order[i] && sortKeyName.includes(order[i])) {
        const orderDir = order[i] === 'desc' ? -1 : 1; // 默认升序，如果是 'desc' 则降序
        if (key) {
          if (a[key] > b[key]) return orderDir;
          if (a[key] < b[key]) return -orderDir;
        }
      }
    }
    return 0; // 如果所有字段相同，返回 0，不改变顺序
  });

  // 初始化 Map，用来记录每个字段的首次出现的索引
  const keyValMaps = keys.reduce(
    (acc: Record<string, Map<any, any>>, key: string) => {
      acc[key] = new Map(); // 为每个字段创建一个 Map
      return acc;
    },
    {},
  );
  // 初始化 rowSpan 字段
  const rebackArr = dataCopy.map((item) => {
    const newItem = { ...item };
    keys.forEach((key) => {
      newItem[`${key}RowSpan`] = 0; // 初始化每个字段的 rowSpan
    });
    return newItem;
  });
  // 用于计算每个字段的 rowSpan（保留你原有的 rowSpanArr 逻辑）
  keys.forEach((key) => {
    const currentKeyMap = keyValMaps[key];
    let groupStartIndex = -1;
    let itemKeyPrevious = 0;
    const rowSpanArr: any = {};
    // 生成对象
    dataCopy.forEach((item, index) => {
      const itemKey = item[key];
      if (
        !currentKeyMap?.has(itemKey) ||
        (currentKeyMap.has(itemKey) && itemKeyPrevious !== itemKey)
      ) {
        // 如果是第一次遇到该值，记录其索引
        itemKeyPrevious = itemKey;
        currentKeyMap?.set(itemKey, index);
        groupStartIndex = index; // 记录组的起始索引
        rebackArr[groupStartIndex][`${key}RowSpan`] = 1;
        // 行row获取
        if (!rowSpanArr[key]) {
          rowSpanArr[key] = {}; // 确保 key 存在
        }
        rowSpanArr[key][groupStartIndex] = {
          rowSpan: 1,
          val: [{ ...item }],
        };
      } else {
        rebackArr[groupStartIndex][`${key}RowSpan`] =
          rebackArr[groupStartIndex][`${key}RowSpan`] + 1;
        // 行row获取
        if (rowSpanArr[key] && rowSpanArr[key][groupStartIndex]) {
          rowSpanArr[key][groupStartIndex].rowSpan += 1;
        }
        rowSpanArr[key][groupStartIndex]?.val?.push(item);
      }
    });
  });
  return [rebackArr, rowSpanArr];
};
